package com.lxw.oa.util;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class StringUtil extends org.apache.commons.lang3.StringUtils {
    /**
     * 进来两个数组，一个为字段名数组，一个为对应的字段值数组，返回SQL插入数据所用的两个字符串
     * @param column
     * @param value
     * @return
     */
    public static String [] toSqlStr(String[] column,String[] value){
         String[] sqlStr=new String[2];
        String columnStr="";
        String valueStr="";
         if(column.length==value.length){
             for(int i=0;i<column.length;i++){
                  if("id".equalsIgnoreCase(column[i])){

                  }else{
                      columnStr+=column[i];
                      valueStr+="'"+value[i]+"'";
                      if(i<column.length-1){
                          columnStr+=",";
                          valueStr+=",";
                      }
                  }

             }
         }else{
             System.err.println("==========================字段数量与数值数量不一致");
         }
        sqlStr[0]=columnStr;
        sqlStr[1]=valueStr;
        return sqlStr;
    }

    /**
     * 进来两个数组，返回sql跟新的语句
     * @param column
     * @param value
     * @return
     */
    public static String  toSqlUpdateStr(String[] column,String[] value){
        String sqlStr="";
        if(column.length==value.length){
            for(int i=0;i<column.length;i++){
                if("id".equalsIgnoreCase(column[i])){

                }else{
                    sqlStr+=column[i]+"='"+value[i]+"'";
                    if(i<column.length-1){
                        sqlStr+=",";
                    }
                }

            }
        }else{
            System.err.println("==========================字段数量与数值数量不一致");
        }

        return sqlStr;
    }

    /**
     * 进来两个数组，返回sql查询语句字符串
     * @return
     */
    public static String  toSqlSearchStr(Map<String,Object> map){
        String sqlStr="";
        List<String>list=new ArrayList(map.keySet());
        Iterator<String>it=list.iterator();
        while(it.hasNext()){
            String column=it.next();
            if(column.split("@@").length<2){
                it.remove();
            }else if("".equals(map.get(column).toString())){
                it.remove();
            }
        }
         for(int i=0;i<list.size();i++){
             String demo=list.get(i);
             String columnValue=map.get(demo).toString();
             String likeOrEql=demo.split("@@")[1];
             String column=demo.split("@@")[0];
             if("like".equalsIgnoreCase(likeOrEql)){
                 sqlStr+=column+" like '%"+columnValue+"%'";
             }else if("eql".equalsIgnoreCase(likeOrEql)){
                 sqlStr+=column+" = '"+columnValue+"'";
             }else{
                 System.err.println("字段筛选方式有误");
             }
             if(i<list.size()-1){
                 sqlStr+=" and ";
             }
         }
        return sqlStr;
    }

    /**
     * 判断一个字符串是不是空
     *
     * @param value
     *            要判断的字符串
     * @return 如果字符串是null或""，则返回true，否则返回false
     */
    public static boolean isEmpty(String value) {
        return value == null || value.equals("")
                || value.equalsIgnoreCase("null");
    }


    /**
     * 判断一个object是不是空字符串
     *
     * @param value
     *            要判断的object
     * @return 如果这个object是null 或者 toString=="" 则返回true，否则返回false
     */
    public static boolean isEmpty(Object value) {
        return value == null || value.toString().equals("");
    }


    /**
     * * 判断一个字符串是否为非空串
     *
     * @param str String
     * @return true：非空串 false：空串
     */
    public static boolean isNotEmpty(String str)
    {
        return !isEmpty(str);
    }

    /**
     * 获取参数不为空值
     *
     * @param value defaultValue 要判断的value
     * @return value 返回值
     */
    public static <T> T nvl(T value, T defaultValue)
    {
        return value != null ? value : defaultValue;
    }




    /**
     * 截取字符串
     *
     * @param str 字符串
     * @param start 开始
     * @param end 结束
     * @return 结果
     */
    public static String substring(final String str, int start, int end)
    {
        if (str == null)
        {
            return "";
        }

        if (end < 0)
        {
            end = str.length() + end;
        }
        if (start < 0)
        {
            start = str.length() + start;
        }

        if (end > str.length())
        {
            end = str.length();
        }

        if (start > end)
        {
            return "";
        }

        if (start < 0)
        {
            start = 0;
        }
        if (end < 0)
        {
            end = 0;
        }

        return str.substring(start, end);
    }

    /**
     * * 判断一个对象是否为空
     *
     * @param object Object
     * @return true：为空 false：非空
     */
    public static boolean isNull(Object object)
    {
        return object == null;
    }

    /**
     * * 判断一个对象是否非空
     *
     * @param object Object
     * @return true：非空 false：空
     */
    public static boolean isNotNull(Object object)
    {
        return !isNull(object);
    }

    /**
     * 是否包含字符串
     *
     * @param str 验证字符串
     * @param strs 字符串组
     * @return 包含返回true
     */
    public static boolean inStringIgnoreCase(String str, String... strs)
    {
        if (str != null && strs != null)
        {
            for (String s : strs)
            {
                if (str.equalsIgnoreCase(trim(s)))
                {
                    return true;
                }
            }
        }
        return false;
    }









}
